# _*_ coding:utf-8 _*_
import math
# --------------------------简单的2D向量类--------------------
class Vector2D(object):
    '''
    向量在计算机中实质也是一个点来表示，但是这个点是由x坐标和y坐标叠加而来，也就是一个向量
    可以分解成x方向长度和y方向长度，所以向量表示长度和方向
    '''
    def __init__(self,x=0.0,y=0.0):
        self.x=x
        self.y=y
    def __str__(self):
        return "(%s,%s)"%(self.x,self.y)

    # 向量大小(向量的模)
    def get_magnitude(self):
        return math.sqrt(self.x**2+self.y**2)

    # 向量加法
    def __add__(self, rhs):
        return Vector2D(self.x + rhs.x, self.y + rhs.y)

    # 向量减法
    def __sub__(self, rhs):
        return Vector2D(self.x - rhs.x, self.y - rhs.y)
    # 向量乘法
    def __mul__(self, scalar):
        return Vector2D(self.x * scalar, self.y * scalar)
    # 向量除法
    def __truediv__(self, scalar):
        return Vector2D(self.x / scalar, self.y / scalar)
    # 把任意向量方向不变的缩放（体现在数字上就是x和y等比例的缩放）到一个单位向量，这叫向量的规格（正规）化
    def normalize(self):
        magnitude = self.get_magnitude()
        if magnitude!=0:
            self.x /= magnitude
            self.y /= magnitude

    # 两点向量
    @classmethod
    def from_points(cls, P1, P2):
        return cls(P2[0]-P1[0],P2[1]-P1[1])

    def to_point(self):
        return (self.x,self.y)

# A=(1,1)
# B=(4,5)
# AB=Vector2D.from_points(A,B)
# size=AB.get_magnitude()
# print(AB)
# print(size)

# --------------------------简单的3D向量类--------------------
class Vector3D(object):
    '''
    向量在计算机中实质也是一个三维点来表示，也就是一个向量可以分解成x,y,z轴方向长度，所以向量表示长度和方向
    '''
    def __init__(self,x=0.0,y=0.0,z=0.0):
        self.x=x
        self.y=y
        self.z=z
    def __str__(self):
        return "(%s,%s,%s)"%(self.x,self.y,self.z)

    # 向量大小(向量的模)
    def get_magnitude(self):
        return math.sqrt(self.x**2+self.y**2+self.z**2)

    # 向量加法
    def __add__(self, rhs):
        return Vector3D(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z)

    # 向量减法
    def __sub__(self, rhs):
        return Vector3D(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
    # 向量乘法
    def __mul__(self, scalar):
        return Vector3D(self.x * scalar, self.y * scalar, self.z * scalar)
    # 向量除法
    def __truediv__(self, scalar):
        return Vector3D(self.x / scalar, self.y / scalar, self.z / scalar)
    # 把任意向量方向不变的缩放（体现在数字上就是x和y等比例的缩放）到一个单位向量，这叫向量的规格（正规）化
    def normalize(self):
        magnitude = self.get_magnitude()
        if magnitude!=0:
            self.x /= magnitude
            self.y /= magnitude
            self.z /= magnitude

    # 两点向量
    @classmethod
    def from_points(cls, P1, P2):
        return cls(P2[0] - P1[0], P2[1] - P1[1], P2[2] - P1[2])

    def to_point(self):
        return (self.x,self.y,self.z)

A=(2,3,4)
B=(5,6,7)
AB=Vector3D.from_points(A,B)
size=AB.get_magnitude()
print(AB)
print(size)